// 首先我们在调用 Promise 时，会返回一个 Promise 对象。
// 构建 Promise 对象时，需要传入一个 executor 函数，Promise 的主要业务流程都在 executor 函数中执行。
// 如果运行在 excutor 函数中的业务执行成功了，会调用 resolve 函数；如果执行失败了，则调用 reject 函数。
// Promise 的状态不可逆，同时调用 resolve 函数和 reject 函数，默认会采取第一次调用的结果。


// 同步
const PENDING = 'PENDING'
const FULFILLED = "FULFILLED"
const REJECTED = "REJECTED"

class Promise {
  // new promise时， 需要传递一个executor()执行器，执行器立即执行；
  // executor接受两个参数，分别是resolve和reject
  constructor(executor) {
    this.status = PENDING;
    // 存放成功状态的值，默认为 undefined
    this.value = undefined;
    // 存放失败状态的值，默认为 undefined
    this.reason = undefined;

    let resolve = (value) => {
      if(this.status = PENDING) {
        console.log('我是resolve')
        this.status = FULFILLED;
        this.value = value;
      }
    }

    // 调用此方法就是失败
    let reject = (reason) => {
      if(this.status === PENDING) {
        this.status = REJECTED;
        this.reason = reason;
      }
    }

    try {
      // 立即执行，将 resolve 和 reject 函数传给使用者
      executor(resolve)
    } catch (error) {
      // 发生异常时执行失败逻辑
      executor(reject)
    }
  }

  // 包含一个 then 方法，并接收两个参数 onFulfilled、onRejected
  then(onFulfilled, onRejected) {
    console.log('同步的话，当前status是正常的， 但是异步的话，当前状态status 一直是 PENDING', 'this.status=' + this.status)
    if(this.status === FULFILLED) {
      onFulfilled(this.value)
    }

    if(this.status === REJECTED) {
      onRejected(this.reason)
    }
  }
}


let promise = new Promise((resolve, reject) => {
  // 现在只是同步操作， 如果传入异步操作怎么办
  resolve('成功')

  // 异步
  // setTimeout(() => {
  //   resolve('成功')
  // })
  // 打印结果：我是resolve
  // 解释
  // 执行测试脚本后发现，promise 没有任何返回。
  // 因为 promise 调用 then 方法时，当前的 promise 并没有成功，一直处于 pending 状态。
  // 所以如果当调用 then 方法时，当前状态是 pending，我们需要先将成功和失败的回调分别存放起来，在executor()的异步任务被执行时，触发 resolve 或 reject，依次调用成功或失败的回调。
  // 下一个版本 文件 ./03async

})
.then((data) => {
    console.log('success', data)
  },
  (err) => {
    console.log('faild', err)
  }
)


module.exports = Promise;